chore(deps): update rust crate fancy-regex to 0.20.0 - #23

v0.20.1

Compare Source

Added

• A new Expr::has_descendant_or_self method to easily traverse the Expr descendants to find an Expr matching a predicate. (#​319)
• Add a RegexOptionsBuilder::optimize / RegexBuilder::optimize flag to disable the expression-tree optimization pass (enabled by default), and rework it into two tiers: optimize() now takes an OptimizeOptions struct with a find_not_empty flag that skips only the KeepOut (\K) and trailing-lookahead rewrites, while the safe rewrites still apply — so find_not_empty patterns benefit from them instead of skipping the whole pass. The decision on whether to optimize is centralized on RegexOptions::should_optimize and forwarded to the prefilter helpers (start_bytes, required_bytes) so they analyze the same tree as the compile path. (#​323)
• Support control character escapes \cX and \C-X in Oniguruma mode, e.g. \ca matches \x01 and \c\\ matches \x1C, both inside and outside of character classes. Without Oniguruma mode they are still invalid escapes. (#​320)

Changed

Fixed

• Positive lookaheads are now atomic, as in Oniguruma and PCRE: once a lookahead has matched, a later failure no longer backtracks into it to try another way of matching it. For example (?=x|(x))\1x no longer matches xx. (#​313)
• A hard variable-length lookbehind no longer reuses the candidate start positions left behind by a previous lookbehind that matched (or by a negative lookbehind whose body matched), which gave wrong results such as (b*)(?<!\1)c matching abc, or hit the backtrack limit when a pattern had two such lookbehinds, like (a*)b(?<=\1b)(c*)d(?<=\2d). (#​314)
• A repetition with a minimum count whose body can match an empty string (e.g. (?:a|(?=b)){2,}) could stop before reaching the minimum when it ran again at a position its previous run had reached, for example inside a repeated lookahead: (?:(?=(?:a|(?=b)){2,})a){2} matched aa. (#​312)
• A {n,} repetition whose body can match an empty string ended as soon as an iteration matched empty, even below the minimum. When the first iteration matched empty, the last required one now still runs, so (?:(?=^)a*){2,}b matches aab. A body that reads a capture group it sets itself can match differently in the next iteration, so there all required iterations run, and ^(?:(?(1)a|())){3,}$ no longer matches an empty string. (#​325)
• A conditional whose condition fails no longer leaves its entry on the VM's explicit stack. Before, an enclosing atomic group or possessive repeat read that entry at its end and kept its backtrack branches: (z)?(?>a*(?(1)x))a matched "aaa". (#​316)
• A conditional whose true branch is a group of alternatives, such as (?(1)(?:a|b)), was parsed as (?(1)a|b), so b became the false branch. (#​315)
• Inline flags set inside a capturing, named, atomic, lookaround, conditional or absent group, like (a(?i)b)c, now end with the group. Before, they leaked to the rest of the pattern, so (a(?i)b)c matched aBC and (?x)G(o(?-x)o) g did not ignore the spaces after the group. Only (?:...) and (?flags:...) restored them. (#​317)
• In Oniguruma mode, {,} is now literal text, as in Oniguruma, instead of being parsed as {0,}. For example (?:ab){,} matches ab{,}. {,n} is still {0,n}, and without Oniguruma mode {,} is unchanged. (#​321)
• In Oniguruma mode, a ? after an interval with swapped limits, like a{3,2}?, is now another quantifier, as in Oniguruma, so it makes the possessive a{2,3} optional. Before, it made the repeat lazy, so a{3,2}? matched aa in aaa and didn't match an empty string. A ?, * or + after a repeated empty group, like in (?:)** or (?:){3,2}?, is now dropped along with it instead of failing to parse. (#​322)
• In Oniguruma mode, a ? after a fixed interval, like a{3}?, is now another quantifier, as in Oniguruma, so a{3}? means (?:a{3})?. Before, it made the repeat lazy, which doesn't change anything for a fixed count, so a{3}? didn't match aa and a{3}?? matched aaa instead of an empty string. a{3,3}? is still lazy, and without Oniguruma mode a{3}? is unchanged.
• A backref or conditional inside the group it refers to now sees the group's previous capture, as in PCRE and Perl. Before, it saw the new start of the group with the end of its previous capture, so (?:(\1|a)b){2} panicked on abab and ^((?(1)b|a))$ matched b but not a. (#​328)

v0.20.0

Compare Source

Added

• Add RegexOptionsBuilder::build_delegate_prefilter to disable building the prefilter (#​282)
• Add RegexOptionsBuilder::start_bytes that returns the first bytes that can match a pattern so you can build your own prefilter (#​282)
• Add RegexOptionsBuilder::required_bytes that returns the required bytes for a pattern to match (#​287)
• Add RegexOptionsBuilder::max_prog_size / RegexBuilder::max_prog_size to cap the number of VM instructions emitted while compiling. Subroutine calls are inlined at compile time, so a self- or mutually-recursive pattern can expand without bound even while the recursion-depth cap is respected; this bounds the emitted instruction vector instead. Exceeding the cap returns CompileError::PatternTooComplex. Disabled by default. (#​298)
• Implement support for variable length hard lookbehinds, by seeking backwards to candidate match start positions and then matching forward as usual. The reverse DFA honours delegate_size_limit and delegate_dfa_size_limit. (#​286, #​309)
• Add RegexOptionsBuilder::delegate_dfa_skip_cache_capacity_check / RegexBuilder::delegate_dfa_skip_cache_capacity_check, enabled by default. Setting it to false makes the reverse DFA of a variable-length lookbehind strictly honour delegate_dfa_size_limit, so a too-small limit becomes a compile error. (#​309)
• Add ByteSet::is_subset to test whether one byte set is a subset of another. (#​289)

Changed

• If a lookbehind consists of an Alt containing only easy expressions and at least 4 branches (and no capture groups), compile it as a variable lookbehind (if the feature is enabled) instead of trying every branch as its own const-size lookbehind. One reverse-DFA delegate over the whole alternation is much cheaper per attempt, and grants a perf boost. (#​285)
• Word boundaries (\b, \B, \<, \>) are no longer marked hard outside a lookbehind. regex-automata supports them, so a pattern like \b(?:foo|bar|baz)\b now compiles to a single delegated engine instead of one branch per alternative — previously it grew linearly with the number of alternatives. They remain hard inside a lookbehind, since regex-automata's reverse DFA can't run a variable-length lookbehind on unicode haystacks. The half-boundary variants and \Z are still always hard. (#​311)
• The parser now tracks every capture group declared with the same name; Regex::capture_names reports the name for each of them, and named backrefs resolve to the last group with that name (#​177)

Fixed

• The reverse lazy DFA built for a variable-length lookbehind failed to compile when it needed a larger cache capacity than the configured delegate_dfa_size_limit (or the default of 2 MiB); for example (?<=\p{L}{99,100})x failed to compile with default settings. The capacity is now rounded up to the minimum required. Ordinary delegates were not affected because the meta engine falls back to another engine when the lazy DFA cannot be built. (#​309)
• delegate_dfa_size_limit now sets the lazy DFA cache capacity (hybrid_cache_capacity) as documented, instead of the fully compiled DFA size limit. It had been forwarded to the wrong regex-automata option since the switch from the regex crate. (#​307)
• Fix bug with literal bytes being used in unicode mode unexpectedly: in Unicode mode, \xHH escapes above 0x7F now match the Unicode codepoint (as UTF-8 bytes) instead of the raw byte, so e.g. \xFF matches ÿ rather than the byte 0xFF. In bytes modes the raw byte is matched as before. (#​292)
• Fix case-insensitive prefilter computation for non-ASCII class ranges that fold to characters with different lead bytes (e.g. (?i)[à-ÿ]), which previously could miss candidate start positions. (#​296)
• Fix ^ / $ and their multi-line variants matching at the start/end of arbitrary-byte haystacks in Ascii and UnicodeBytes bytes modes, where the match position was not a UTF-8 codepoint boundary. (#​300)
• Fix seek optimization dropping matches when conditionals had empty branches, e.g. (a)?b(?(1)c) no longer fails to match b. (#​304)
• Fix hard variable-length lookbehind reverse DFA ignoring the caller's Unicode and bytes-mode settings, giving wrong results in non-Unicode bytes modes (e.g. (?<=(\w+)\1)x on ééx). (#​310)

v0.19.2

Compare Source

Added

• Add a leftmost_longest feature (off by default) that adds a method to the RegexBuilder/RegexOptionsBuilder for building a VM which would operate in leftmost-longest match mode instead of the regular leftmost-first mode. Useful for POSIX compliance. (#​281)

Changed

Fixed

• Fix a panic in capture_names() for a pattern with a zero-repeated named group such as (?<n>a){0} (#​275)
• Literal bytes were being encoded as utf-8 in Ascii mode, now they match the exact byte literal

v0.19.1

Compare Source

Added

• Add a perf-dfa-full feature (off by default, mirroring the regex crate) that lets regex-automata eagerly build fully compiled dense DFAs for small patterns, for workloads that compile few regexes and match them very heavily (#​272)

Changed

• Add VM instruction for case insensitive literals when in Unicode mode, to keep the build cost bounded (#​268) and ensured the toy example graph output remains readable instead of being super verbose (#​269)
• Compilation performance: the regex-automata dependency no longer enables the dfa-build feature by default. With dfa-build enabled, meta::Regex eagerly determinizes a full dense DFA for every small pattern, which dominated build time of simple class-containing patterns (e.g. \b(extern)\s+(crate) compiled ~4x slower than with the regex crate, which also ships without dfa-build); searches use the lazy DFA instead, with no measurable match-time difference (#​272)
• Compilation performance: identical delegated fragments within one compile now share a single regex-automata engine instead of each building their own. Alternation-heavy patterns (TextMate grammar lookbehinds especially) often repeat the same fragment many times; on such patterns this removes a large share of build time (#​277)

Fixed

• The playground didn't show when a literal or backreference was being matched case insensitively in the analysis tree view (#​269)
• Seek patterns could become very large when recursive backrefs and subroutine calls were inlined, without bringing much benefit (#​270)
• The optimize_nested_repeats pass could rewrite an optional capture group like (\w+)? into (\w*), causing an unmatched optional group to be reported as an empty match (Some("")) instead of None (#​276)

v0.19.0

Compare Source

Added

• Add BytesMode and the RegexInput trait so the matching and capture APIs can operate on strings or bytes, and allows to opt out of unicode handling if desired (#​248)
  • Also allows searching within a range without slicing (#​253)
  • Assertions can be overridden at runtime, if the regex builder allow_input_assertion_overrides option was used (#​254)
  • Search can be performed in anchored mode, searching only at the start position specified (#​263)
• Add experimental seek optimization to only invoke the VM at candidate positions where a match could occur (#​246)
• Add RegexBuilder::disallow_empty_match_at_eof_after_newline to reject empty matches at the end of the haystack following a trailing newline, to match Oniguruma behavior (#​247)
• Add RegexSet API for efficiently matching multiple patterns against the same text (#​255)

Changed

• Case-insensitive backreference comparison of non-ASCII text now uses direct Unicode simple case folding instead of building a regex engine per comparison, which makes patterns like (?i)(\w+)\1 orders of magnitude faster on non-ASCII haystacks. The comparison is now strict fold equality over the captured text's byte-length window: a case-folded prefix of the window no longer counts as a match (previously a substring search could accept one and misalign the match end)
• Compilation performance: delegated regex-automata engines (including the whole pattern in the easy case) are now built from a directly-constructed Hir instead of a re-serialized pattern string, and RegexSet parses each pattern once for both of its set-wide engines instead of three times. This reduces compile time and peak compile memory, especially for RegexSet and small easy patterns
• Match performance: the backtracking VM's working memory (saves, backtrack stack, delegate slots) is pooled and reused across runs, making is_match/find/find_iter and RegexSet candidate verification allocation-free per call; RegexSet::find_input no longer allocates at failed candidate positions. Short and repeated matches improve substantially (up to ~30% for small patterns, ~10% for find_iter over many matches); single very long backtracking runs, where per-run setup is fully amortized anyway, can be a few percent slower
• Matches, CaptureMatches, Captures, and SubCaptureMatches are now generic over RegexInput, which is a breaking change for code that named these types explicitly (#​248)
• Patterns no longer force Unicode mode during parsing, and inline (?u) / (?-u) flags are accepted when they agree with the builder configuration

Fixed

• Fix bug whereby inline flags were not overriding the builder options (#​247)
• Fix bug whereby \G optimizations were applying where they shouldn't, giving wrong results (#​256)
• Support Oniguruma quantifier parsing rules, whereby swapped ordering causes possessiveness, + only causes possessiveness after ?, * or + (#​258)

Upgrade guide

If you previously stored i.e. Captures, you would need to change the type to Captures<str> to get the code to compile.